﻿/*!
* angular-formly JavaScript Library v8.2.1
*
* @license MIT (http://license.angular-formly.com)
*
* built with ♥ by Astrism <astrisms@gmail.com>, Kent C. Dodds <kent@doddsfamily.us>
* (ó ì_í)=óò=(ì_í ò)
*/
(function webpackUniversalModuleDefinition(root, factory) {
    if (typeof exports === 'object' && typeof module === 'object')
        module.exports = factory(require("angular"), require("api-check"));
    else if (typeof define === 'function' && define.amd)
        define(["angular", "api-check"], factory);
    else if (typeof exports === 'object')
        exports["ngFormly"] = factory(require("angular"), require("api-check"));
    else
        root["ngFormly"] = factory(root["angular"], root["apiCheck"]);
})(this, function (__WEBPACK_EXTERNAL_MODULE_3__, __WEBPACK_EXTERNAL_MODULE_5__) {
    return /******/ (function (modules) { // webpackBootstrap
        /******/ 	// The module cache
        /******/ 	var installedModules = {};

        /******/ 	// The require function
        /******/ 	function __webpack_require__(moduleId) {

            /******/ 		// Check if module is in cache
            /******/ 		if (installedModules[moduleId])
                /******/ 			return installedModules[moduleId].exports;

            /******/ 		// Create a new module (and put it into the cache)
            /******/ 		var module = installedModules[moduleId] = {
                /******/ 			exports: {},
                /******/ 			id: moduleId,
                /******/ 			loaded: false
                /******/
            };

            /******/ 		// Execute the module function
            /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

            /******/ 		// Flag the module as loaded
            /******/ 		module.loaded = true;

            /******/ 		// Return the exports of the module
            /******/ 		return module.exports;
            /******/
        }


        /******/ 	// expose the modules object (__webpack_modules__)
        /******/ 	__webpack_require__.m = modules;

        /******/ 	// expose the module cache
        /******/ 	__webpack_require__.c = installedModules;

        /******/ 	// __webpack_public_path__
        /******/ 	__webpack_require__.p = "";

        /******/ 	// Load entry module and return exports
        /******/ 	return __webpack_require__(0);
        /******/
    })
    /************************************************************************/
    /******/([
    /* 0 */
    /***/ function (module, exports, __webpack_require__) {

        'use strict';

        Object.defineProperty(exports, '__esModule', {
            value: true
        });

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

        var _indexCommon = __webpack_require__(1);

        var _indexCommon2 = _interopRequireDefault(_indexCommon);

        exports['default'] = _indexCommon2['default'];
        module.exports = exports['default'];

        /***/
    },
    /* 1 */
    /***/ function (module, exports, __webpack_require__) {

        'use strict';

        Object.defineProperty(exports, '__esModule', {
            value: true
        });

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

        var _angularFix = __webpack_require__(2);

        var _angularFix2 = _interopRequireDefault(_angularFix);

        var _providersFormlyApiCheck = __webpack_require__(4);

        var _providersFormlyApiCheck2 = _interopRequireDefault(_providersFormlyApiCheck);

        var _otherDocsBaseUrl = __webpack_require__(6);

        var _otherDocsBaseUrl2 = _interopRequireDefault(_otherDocsBaseUrl);

        var _providersFormlyUsability = __webpack_require__(7);

        var _providersFormlyUsability2 = _interopRequireDefault(_providersFormlyUsability);

        var _providersFormlyConfig = __webpack_require__(8);

        var _providersFormlyConfig2 = _interopRequireDefault(_providersFormlyConfig);

        var _providersFormlyValidationMessages = __webpack_require__(10);

        var _providersFormlyValidationMessages2 = _interopRequireDefault(_providersFormlyValidationMessages);

        var _servicesFormlyUtil = __webpack_require__(11);

        var _servicesFormlyUtil2 = _interopRequireDefault(_servicesFormlyUtil);

        var _servicesFormlyWarn = __webpack_require__(12);

        var _servicesFormlyWarn2 = _interopRequireDefault(_servicesFormlyWarn);

        var _directivesFormlyCustomValidation = __webpack_require__(13);

        var _directivesFormlyCustomValidation2 = _interopRequireDefault(_directivesFormlyCustomValidation);

        var _directivesFormlyField = __webpack_require__(14);

        var _directivesFormlyField2 = _interopRequireDefault(_directivesFormlyField);

        var _directivesFormlyFocus = __webpack_require__(15);

        var _directivesFormlyFocus2 = _interopRequireDefault(_directivesFormlyFocus);

        var _directivesFormlyForm = __webpack_require__(16);

        var _directivesFormlyForm2 = _interopRequireDefault(_directivesFormlyForm);

        var _directivesFormlyFormController = __webpack_require__(17);

        var _directivesFormlyFormController2 = _interopRequireDefault(_directivesFormlyFormController);

        var _runFormlyNgModelAttrsManipulator = __webpack_require__(18);

        var _runFormlyNgModelAttrsManipulator2 = _interopRequireDefault(_runFormlyNgModelAttrsManipulator);

        var _runFormlyCustomTags = __webpack_require__(19);

        var _runFormlyCustomTags2 = _interopRequireDefault(_runFormlyCustomTags);

        var ngModuleName = 'formly';

        exports['default'] = ngModuleName;

        var ngModule = _angularFix2['default'].module(ngModuleName, []);

        ngModule.constant('formlyApiCheck', _providersFormlyApiCheck2['default']);
        ngModule.constant('formlyErrorAndWarningsUrlPrefix', _otherDocsBaseUrl2['default']);
        ngModule.constant('formlyVersion', ("8.2.1")); // <-- webpack variable

        ngModule.provider('formlyUsability', _providersFormlyUsability2['default']);
        ngModule.provider('formlyConfig', _providersFormlyConfig2['default']);

        ngModule.factory('formlyValidationMessages', _providersFormlyValidationMessages2['default']);
        ngModule.factory('formlyUtil', _servicesFormlyUtil2['default']);
        ngModule.factory('formlyWarn', _servicesFormlyWarn2['default']);

        ngModule.directive('formlyCustomValidation', _directivesFormlyCustomValidation2['default']);
        ngModule.directive('formlyField', _directivesFormlyField2['default']);
        ngModule.directive('formlyFocus', _directivesFormlyFocus2['default']);
        ngModule.directive('formlyForm', _directivesFormlyForm2['default']);
        ngModule.controller('FormlyFormController', _directivesFormlyFormController2['default']);

        ngModule.run(_runFormlyNgModelAttrsManipulator2['default']);
        ngModule.run(_runFormlyCustomTags2['default']);
        module.exports = exports['default'];

        /***/
    },
    /* 2 */
    /***/ function (module, exports, __webpack_require__) {

        // some versions of angular don't export the angular module properly,
        // so we get it from window in this case.
        'use strict';

        Object.defineProperty(exports, '__esModule', {
            value: true
        });
        var angular = __webpack_require__(3);

        /* istanbul ignore next */
        if (!angular.version) {
            angular = window.angular;
        }
        exports['default'] = angular;
        module.exports = exports['default'];

        /***/
    },
    /* 3 */
    /***/ function (module, exports) {

        module.exports = __WEBPACK_EXTERNAL_MODULE_3__;

        /***/
    },
    /* 4 */
    /***/ function (module, exports, __webpack_require__) {

        'use strict';

        Object.defineProperty(exports, '__esModule', {
            value: true
        });

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

        var _angularFix = __webpack_require__(2);

        var _angularFix2 = _interopRequireDefault(_angularFix);

        var _apiCheck = __webpack_require__(5);

        var _apiCheck2 = _interopRequireDefault(_apiCheck);

        var apiCheck = (0, _apiCheck2['default'])({
            output: {
                prefix: 'angular-formly:',
                docsBaseUrl: __webpack_require__(6)
            }
        });

        function shapeRequiredIfNot(otherProps, propChecker) {
            if (!_angularFix2['default'].isArray(otherProps)) {
                otherProps = [otherProps];
            }
            var type = 'specified if these are not specified: `' + otherProps.join(', ') + '` (otherwise it\'s optional)';

            function shapeRequiredIfNotDefinition(prop, propName, location, obj) {
                var propExists = obj && obj.hasOwnProperty(propName);
                var otherPropsExist = otherProps.some(function (otherProp) {
                    return obj && obj.hasOwnProperty(otherProp);
                });
                if (!otherPropsExist && !propExists) {
                    return apiCheck.utils.getError(propName, location, type);
                } else if (propExists) {
                    return propChecker(prop, propName, location, obj);
                }
            }

            shapeRequiredIfNotDefinition.type = type;
            return apiCheck.utils.checkerHelpers.setupChecker(shapeRequiredIfNotDefinition);
        }

        var formlyExpression = apiCheck.oneOfType([apiCheck.string, apiCheck.func]);
        var specifyWrapperType = apiCheck.typeOrArrayOf(apiCheck.string).nullable;

        var apiCheckProperty = apiCheck.func;

        var apiCheckInstanceProperty = apiCheck.shape.onlyIf('apiCheck', apiCheck.func.withProperties({
            warn: apiCheck.func,
            'throw': apiCheck.func,
            shape: apiCheck.func
        }));

        var apiCheckFunctionProperty = apiCheck.shape.onlyIf('apiCheck', apiCheck.oneOf(['throw', 'warn']));

        var formlyWrapperType = apiCheck.shape({
            name: shapeRequiredIfNot('types', apiCheck.string).optional,
            template: apiCheck.shape.ifNot('templateUrl', apiCheck.string).optional,
            templateUrl: apiCheck.shape.ifNot('template', apiCheck.string).optional,
            types: apiCheck.typeOrArrayOf(apiCheck.string).optional,
            overwriteOk: apiCheck.bool.optional,
            apiCheck: apiCheckProperty.optional,
            apiCheckInstance: apiCheckInstanceProperty.optional,
            apiCheckFunction: apiCheckFunctionProperty.optional,
            apiCheckOptions: apiCheck.object.optional
        }).strict;

        var expressionProperties = apiCheck.objectOf(apiCheck.oneOfType([formlyExpression, apiCheck.shape({
            expression: formlyExpression,
            message: formlyExpression.optional
        }).strict]));

        var modelChecker = apiCheck.oneOfType([apiCheck.string, apiCheck.object]);

        var templateManipulators = apiCheck.shape({
            preWrapper: apiCheck.arrayOf(apiCheck.func).nullable.optional,
            postWrapper: apiCheck.arrayOf(apiCheck.func).nullable.optional
        }).strict.nullable;

        var validatorChecker = apiCheck.objectOf(apiCheck.oneOfType([formlyExpression, apiCheck.shape({
            expression: formlyExpression,
            message: formlyExpression.optional
        }).strict]));

        var watcherChecker = apiCheck.typeOrArrayOf(apiCheck.shape({
            expression: formlyExpression.optional,
            listener: formlyExpression.optional,
            runFieldExpressions: apiCheck.bool.optional
        }));

        var fieldOptionsApiShape = {
            $$hashKey: apiCheck.any.optional,
            type: apiCheck.shape.ifNot(['template', 'templateUrl'], apiCheck.string).optional,
            template: apiCheck.shape.ifNot(['type', 'templateUrl'], apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,
            templateUrl: apiCheck.shape.ifNot(['type', 'template'], apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,
            key: apiCheck.oneOfType([apiCheck.string, apiCheck.number]).optional,
            model: modelChecker.optional,
            originalModel: modelChecker.optional,
            className: apiCheck.string.optional,
            id: apiCheck.string.optional,
            name: apiCheck.string.optional,
            expressionProperties: expressionProperties.optional,
            extras: apiCheck.shape({
                validateOnModelChange: apiCheck.bool.optional,
                skipNgModelAttrsManipulator: apiCheck.oneOfType([apiCheck.string, apiCheck.bool]).optional
            }).strict.optional,
            data: apiCheck.object.optional,
            templateOptions: apiCheck.object.optional,
            wrapper: specifyWrapperType.optional,
            modelOptions: apiCheck.shape({
                updateOn: apiCheck.string.optional,
                debounce: apiCheck.oneOfType([apiCheck.objectOf(apiCheck.number), apiCheck.number]).optional,
                allowInvalid: apiCheck.bool.optional,
                getterSetter: apiCheck.bool.optional,
                timezone: apiCheck.string.optional
            }).optional,
            watcher: watcherChecker.optional,
            validators: validatorChecker.optional,
            asyncValidators: validatorChecker.optional,
            parsers: apiCheck.arrayOf(formlyExpression).optional,
            formatters: apiCheck.arrayOf(formlyExpression).optional,
            noFormControl: apiCheck.bool.optional,
            hide: apiCheck.bool.optional,
            hideExpression: formlyExpression.optional,
            ngModelElAttrs: apiCheck.objectOf(apiCheck.string).optional,
            ngModelAttrs: apiCheck.objectOf(apiCheck.shape({
                statement: apiCheck.shape.ifNot(['value', 'attribute', 'bound', 'boolean'], apiCheck.any).optional,
                value: apiCheck.shape.ifNot('statement', apiCheck.any).optional,
                attribute: apiCheck.shape.ifNot('statement', apiCheck.any).optional,
                bound: apiCheck.shape.ifNot('statement', apiCheck.any).optional,
                boolean: apiCheck.shape.ifNot('statement', apiCheck.any).optional
            }).strict).optional,
            elementAttributes: apiCheck.objectOf(apiCheck.string).optional,
            optionsTypes: apiCheck.typeOrArrayOf(apiCheck.string).optional,
            link: apiCheck.func.optional,
            controller: apiCheck.oneOfType([apiCheck.string, apiCheck.func, apiCheck.array]).optional,
            validation: apiCheck.shape({
                show: apiCheck.bool.nullable.optional,
                messages: apiCheck.objectOf(formlyExpression).optional,
                errorExistsAndShouldBeVisible: apiCheck.bool.optional
            }).optional,
            formControl: apiCheck.typeOrArrayOf(apiCheck.object).optional,
            value: apiCheck.func.optional,
            runExpressions: apiCheck.func.optional,
            templateManipulators: templateManipulators.optional,
            resetModel: apiCheck.func.optional,
            updateInitialValue: apiCheck.func.optional,
            initialValue: apiCheck.any.optional,
            defaultValue: apiCheck.any.optional
        };

        var formlyFieldOptions = apiCheck.shape(fieldOptionsApiShape).strict;

        var formOptionsApi = apiCheck.shape({
            formState: apiCheck.object.optional,
            resetModel: apiCheck.func.optional,
            updateInitialValue: apiCheck.func.optional,
            removeChromeAutoComplete: apiCheck.bool.optional,
            templateManipulators: templateManipulators.optional,
            manualModelWatcher: apiCheck.oneOfType([apiCheck.bool, apiCheck.func]).optional,
            watchAllExpressions: apiCheck.bool.optional,
            wrapper: specifyWrapperType.optional,
            fieldTransform: apiCheck.oneOfType([apiCheck.func, apiCheck.array]).optional,
            data: apiCheck.object.optional
        }).strict;

        var fieldGroup = apiCheck.shape({
            $$hashKey: apiCheck.any.optional,
            key: apiCheck.oneOfType([apiCheck.string, apiCheck.number]).optional,
            // danger. Nested field groups wont get api-checked...
            fieldGroup: apiCheck.arrayOf(apiCheck.oneOfType([formlyFieldOptions, apiCheck.object])),
            className: apiCheck.string.optional,
            options: formOptionsApi.optional,
            templateOptions: apiCheck.object.optional,
            wrapper: specifyWrapperType.optional,
            watcher: watcherChecker.optional,
            hide: apiCheck.bool.optional,
            hideExpression: formlyExpression.optional,
            data: apiCheck.object.optional,
            model: modelChecker.optional,
            form: apiCheck.object.optional,
            elementAttributes: apiCheck.objectOf(apiCheck.string).optional
        }).strict;

        var typeOptionsDefaultOptions = _angularFix2['default'].copy(fieldOptionsApiShape);
        typeOptionsDefaultOptions.key = apiCheck.string.optional;

        var formlyTypeOptions = apiCheck.shape({
            name: apiCheck.string,
            template: apiCheck.shape.ifNot('templateUrl', apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,
            templateUrl: apiCheck.shape.ifNot('template', apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,
            controller: apiCheck.oneOfType([apiCheck.func, apiCheck.string, apiCheck.array]).optional,
            link: apiCheck.func.optional,
            defaultOptions: apiCheck.oneOfType([apiCheck.func, apiCheck.shape(typeOptionsDefaultOptions)]).optional,
            'extends': apiCheck.string.optional,
            wrapper: specifyWrapperType.optional,
            data: apiCheck.object.optional,
            apiCheck: apiCheckProperty.optional,
            apiCheckInstance: apiCheckInstanceProperty.optional,
            apiCheckFunction: apiCheckFunctionProperty.optional,
            apiCheckOptions: apiCheck.object.optional,
            overwriteOk: apiCheck.bool.optional
        }).strict;

        _angularFix2['default'].extend(apiCheck, {
            formlyTypeOptions: formlyTypeOptions, formlyFieldOptions: formlyFieldOptions, formlyExpression: formlyExpression, formlyWrapperType: formlyWrapperType, fieldGroup: fieldGroup, formOptionsApi: formOptionsApi
        });

        exports['default'] = apiCheck;
        module.exports = exports['default'];

        /***/
    },
    /* 5 */
    /***/ function (module, exports) {

        module.exports = __WEBPACK_EXTERNAL_MODULE_5__;

        /***/
    },
    /* 6 */
    /***/ function (module, exports, __webpack_require__) {

        "use strict";

        Object.defineProperty(exports, "__esModule", {
            value: true
        });
        exports["default"] = "https://github.com/formly-js/angular-formly/blob/" + ("8.2.1") + "/other/ERRORS_AND_WARNINGS.md#";
        module.exports = exports["default"];

        /***/
    },
    /* 7 */
    /***/ function (module, exports, __webpack_require__) {

        'use strict';

        formlyUsability.$inject = ["formlyApiCheck", "formlyErrorAndWarningsUrlPrefix"];
        Object.defineProperty(exports, '__esModule', {
            value: true
        });

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

        var _angularFix = __webpack_require__(2);

        var _angularFix2 = _interopRequireDefault(_angularFix);

        exports['default'] = formlyUsability;

        // @ngInject
        function formlyUsability(formlyApiCheck, formlyErrorAndWarningsUrlPrefix) {
            var _this = this;

            _angularFix2['default'].extend(this, {
                getFormlyError: getFormlyError,
                getFieldError: getFieldError,
                checkWrapper: checkWrapper,
                checkWrapperTemplate: checkWrapperTemplate,
                getErrorMessage: getErrorMessage,
                $get: function $get() {
                    return _this;
                }
            });

            function getFieldError(errorInfoSlug, message, field) {
                if (arguments.length < 3) {
                    field = message;
                    message = errorInfoSlug;
                    errorInfoSlug = null;
                }
                return new Error(getErrorMessage(errorInfoSlug, message) + (' Field definition: ' + _angularFix2['default'].toJson(field)));
            }

            function getFormlyError(errorInfoSlug, message) {
                if (!message) {
                    message = errorInfoSlug;
                    errorInfoSlug = null;
                }
                return new Error(getErrorMessage(errorInfoSlug, message));
            }

            function getErrorMessage(errorInfoSlug, message) {
                var url = '';
                if (errorInfoSlug !== null) {
                    url = '' + formlyErrorAndWarningsUrlPrefix + errorInfoSlug;
                }
                return 'Formly Error: ' + message + '. ' + url;
            }

            function checkWrapper(wrapper) {
                formlyApiCheck['throw'](formlyApiCheck.formlyWrapperType, wrapper, {
                    prefix: 'formlyConfig.setWrapper',
                    urlSuffix: 'setwrapper-validation-failed'
                });
            }

            function checkWrapperTemplate(template, additionalInfo) {
                var formlyTransclude = '<formly-transclude></formly-transclude>';
                if (template.indexOf(formlyTransclude) === -1) {
                    throw getFormlyError('Template wrapper templates must use "' + formlyTransclude + '" somewhere in them. ' + ('This one does not have "<formly-transclude></formly-transclude>" in it: ' + template) + '\n' + ('Additional information: ' + JSON.stringify(additionalInfo)));
                }
            }
        }
        module.exports = exports['default'];

        /***/
    },
    /* 8 */
    /***/ function (module, exports, __webpack_require__) {

        'use strict';

        formlyConfig.$inject = ["formlyUsabilityProvider", "formlyErrorAndWarningsUrlPrefix", "formlyApiCheck"];
        Object.defineProperty(exports, '__esModule', {
            value: true
        });

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

        function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length) ; i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }

        var _angularFix = __webpack_require__(2);

        var _angularFix2 = _interopRequireDefault(_angularFix);

        var _otherUtils = __webpack_require__(9);

        var _otherUtils2 = _interopRequireDefault(_otherUtils);

        exports['default'] = formlyConfig;

        // @ngInject
        function formlyConfig(formlyUsabilityProvider, formlyErrorAndWarningsUrlPrefix, formlyApiCheck) {
            var _this2 = this;

            var typeMap = {};
            var templateWrappersMap = {};
            var defaultWrapperName = 'default';
            var _this = this;
            var getError = formlyUsabilityProvider.getFormlyError;

            _angularFix2['default'].extend(this, {
                setType: setType,
                getType: getType,
                getTypes: getTypes,
                getTypeHeritage: getTypeHeritage,
                setWrapper: setWrapper,
                getWrapper: getWrapper,
                getWrapperByType: getWrapperByType,
                removeWrapperByName: removeWrapperByName,
                removeWrappersForType: removeWrappersForType,
                disableWarnings: false,
                extras: {
                    disableNgModelAttrsManipulator: false,
                    fieldTransform: [],
                    ngModelAttrsManipulatorPreferUnbound: false,
                    removeChromeAutoComplete: false,
                    defaultHideDirective: 'ng-if',
                    getFieldId: null
                },
                templateManipulators: {
                    preWrapper: [],
                    postWrapper: []
                },
                $get: function $get() {
                    return _this2;
                }
            });

            function setType(options) {
                if (_angularFix2['default'].isArray(options)) {
                    var _ret = (function () {
                        var allTypes = [];
                        _angularFix2['default'].forEach(options, function (item) {
                            allTypes.push(setType(item));
                        });
                        return {
                            v: allTypes
                        };
                    })();

                    if (typeof _ret === 'object') return _ret.v;
                } else if (_angularFix2['default'].isObject(options)) {
                    checkType(options);
                    if (options['extends']) {
                        extendTypeOptions(options);
                    }
                    typeMap[options.name] = options;
                    return typeMap[options.name];
                } else {
                    throw getError('You must provide an object or array for setType. You provided: ' + JSON.stringify(arguments));
                }
            }

            function checkType(options) {
                formlyApiCheck['throw'](formlyApiCheck.formlyTypeOptions, options, {
                    prefix: 'formlyConfig.setType',
                    url: 'settype-validation-failed'
                });
                if (!options.overwriteOk) {
                    checkOverwrite(options.name, typeMap, options, 'types');
                } else {
                    options.overwriteOk = undefined;
                }
            }

            function extendTypeOptions(options) {
                var extendsType = getType(options['extends'], true, options);
                extendTypeControllerFunction(options, extendsType);
                extendTypeLinkFunction(options, extendsType);
                extendTypeDefaultOptions(options, extendsType);
                _otherUtils2['default'].reverseDeepMerge(options, extendsType);
                extendTemplate(options, extendsType);
            }

            function extendTemplate(options, extendsType) {
                if (options.template && extendsType.templateUrl) {
                    delete options.templateUrl;
                } else if (options.templateUrl && extendsType.template) {
                    delete options.template;
                }
            }

            function extendTypeControllerFunction(options, extendsType) {
                var extendsCtrl = extendsType.controller;
                if (!_angularFix2['default'].isDefined(extendsCtrl)) {
                    return;
                }
                var optionsCtrl = options.controller;
                if (_angularFix2['default'].isDefined(optionsCtrl)) {
                    options.controller = function ($scope, $controller) {
                        $controller(extendsCtrl, { $scope: $scope });
                        $controller(optionsCtrl, { $scope: $scope });
                    };
                    options.controller.$inject = ['$scope', '$controller'];
                } else {
                    options.controller = extendsCtrl;
                }
            }

            function extendTypeLinkFunction(options, extendsType) {
                var extendsFn = extendsType.link;
                if (!_angularFix2['default'].isDefined(extendsFn)) {
                    return;
                }
                var optionsFn = options.link;
                if (_angularFix2['default'].isDefined(optionsFn)) {
                    options.link = function () {
                        extendsFn.apply(undefined, arguments);
                        optionsFn.apply(undefined, arguments);
                    };
                } else {
                    options.link = extendsFn;
                }
            }

            function extendTypeDefaultOptions(options, extendsType) {
                var extendsDO = extendsType.defaultOptions;
                if (!_angularFix2['default'].isDefined(extendsDO)) {
                    return;
                }
                var optionsDO = options.defaultOptions || {};
                var optionsDOIsFn = _angularFix2['default'].isFunction(optionsDO);
                var extendsDOIsFn = _angularFix2['default'].isFunction(extendsDO);
                if (extendsDOIsFn) {
                    options.defaultOptions = function defaultOptions(opts, scope) {
                        var extendsDefaultOptions = extendsDO(opts, scope);
                        var mergedDefaultOptions = {};
                        _otherUtils2['default'].reverseDeepMerge(mergedDefaultOptions, opts, extendsDefaultOptions);
                        var extenderOptionsDefaultOptions = optionsDO;
                        if (optionsDOIsFn) {
                            extenderOptionsDefaultOptions = extenderOptionsDefaultOptions(mergedDefaultOptions, scope);
                        }
                        _otherUtils2['default'].reverseDeepMerge(extenderOptionsDefaultOptions, extendsDefaultOptions);
                        return extenderOptionsDefaultOptions;
                    };
                } else if (optionsDOIsFn) {
                    options.defaultOptions = function defaultOptions(opts, scope) {
                        var newDefaultOptions = {};
                        _otherUtils2['default'].reverseDeepMerge(newDefaultOptions, opts, extendsDO);
                        return optionsDO(newDefaultOptions, scope);
                    };
                }
            }

            function getType(name, throwError, errorContext) {
                if (!name) {
                    return undefined;
                }
                var type = typeMap[name];
                if (!type && throwError === true) {
                    throw getError('There is no type by the name of "' + name + '": ' + JSON.stringify(errorContext));
                } else {
                    return type;
                }
            }

            function getTypes() {
                return typeMap;
            }

            function getTypeHeritage(parent) {
                var heritage = [];
                var type = parent;
                if (_angularFix2['default'].isString(type)) {
                    type = getType(parent);
                }
                parent = type['extends'];
                while (parent) {
                    type = getType(parent);
                    heritage.push(type);
                    parent = type['extends'];
                }
                return heritage;
            }

            function setWrapper(_x, _x2) {
                var _again = true;

                _function: while (_again) {
                    var options = _x,
                        name = _x2;
                    _again = false;

                    if (_angularFix2['default'].isArray(options)) {
                        return options.map(function (wrapperOptions) {
                            return setWrapper(wrapperOptions);
                        });
                    } else if (_angularFix2['default'].isObject(options)) {
                        options.types = getOptionsTypes(options);
                        options.name = getOptionsName(options, name);
                        checkWrapperAPI(options);
                        templateWrappersMap[options.name] = options;
                        return options;
                    } else if (_angularFix2['default'].isString(options)) {
                        _x = {
                            template: options,
                            name: name
                        };
                        _x2 = undefined;
                        _again = true;
                        continue _function;
                    }
                }
            }

            function getOptionsTypes(options) {
                if (_angularFix2['default'].isString(options.types)) {
                    return [options.types];
                }
                if (!_angularFix2['default'].isDefined(options.types)) {
                    return [];
                } else {
                    return options.types;
                }
            }

            function getOptionsName(options, name) {
                return options.name || name || options.types.join(' ') || defaultWrapperName;
            }

            function checkWrapperAPI(options) {
                formlyUsabilityProvider.checkWrapper(options);
                if (options.template) {
                    formlyUsabilityProvider.checkWrapperTemplate(options.template, options);
                }
                if (!options.overwriteOk) {
                    checkOverwrite(options.name, templateWrappersMap, options, 'templateWrappers');
                } else {
                    delete options.overwriteOk;
                }
                checkWrapperTypes(options);
            }

            function checkWrapperTypes(options) {
                var shouldThrow = !_angularFix2['default'].isArray(options.types) || !options.types.every(_angularFix2['default'].isString);
                if (shouldThrow) {
                    throw getError('Attempted to create a template wrapper with types that is not a string or an array of strings');
                }
            }

            function checkOverwrite(property, object, newValue, objectName) {
                if (object.hasOwnProperty(property)) {
                    warn('overwriting-types-or-wrappers', ['Attempting to overwrite ' + property + ' on ' + objectName + ' which is currently', JSON.stringify(object[property]) + ' with ' + JSON.stringify(newValue), 'To supress this warning, specify the property "overwriteOk: true"'].join(' '));
                }
            }

            function getWrapper(name) {
                return templateWrappersMap[name || defaultWrapperName];
            }

            function getWrapperByType(type) {
                /* eslint prefer-const:0 */
                var wrappers = [];
                for (var _name in templateWrappersMap) {
                    if (templateWrappersMap.hasOwnProperty(_name)) {
                        if (templateWrappersMap[_name].types && templateWrappersMap[_name].types.indexOf(type) !== -1) {
                            wrappers.push(templateWrappersMap[_name]);
                        }
                    }
                }
                return wrappers;
            }

            function removeWrapperByName(name) {
                var wrapper = templateWrappersMap[name];
                delete templateWrappersMap[name];
                return wrapper;
            }

            function removeWrappersForType(type) {
                var wrappers = getWrapperByType(type);
                if (!wrappers) {
                    return undefined;
                }
                if (!_angularFix2['default'].isArray(wrappers)) {
                    return removeWrapperByName(wrappers.name);
                } else {
                    wrappers.forEach(function (wrapper) {
                        return removeWrapperByName(wrapper.name);
                    });
                    return wrappers;
                }
            }

            function warn() {
                if (!_this.disableWarnings && console.warn) {
                    /* eslint no-console:0 */
                    var args = Array.prototype.slice.call(arguments);
                    var warnInfoSlug = args.shift();
                    args.unshift('Formly Warning:');
                    args.push('' + formlyErrorAndWarningsUrlPrefix + warnInfoSlug);
                    console.warn.apply(console, _toConsumableArray(args));
                }
            }
        }
        module.exports = exports['default'];

        /***/
    },
    /* 9 */
    /***/ function (module, exports, __webpack_require__) {

        'use strict';

        Object.defineProperty(exports, '__esModule', {
            value: true
        });

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

        var _angularFix = __webpack_require__(2);

        var _angularFix2 = _interopRequireDefault(_angularFix);

        exports['default'] = {
            containsSelector: containsSelector, containsSpecialChar: containsSpecialChar, formlyEval: formlyEval, getFieldId: getFieldId, reverseDeepMerge: reverseDeepMerge, findByNodeName: findByNodeName,
            arrayify: arrayify, extendFunction: extendFunction, extendArray: extendArray, startsWith: startsWith, contains: contains
        };

        function containsSelector(string) {
            return containsSpecialChar(string, '.') || containsSpecialChar(string, '[') && containsSpecialChar(string, ']');
        }

        function containsSpecialChar(a, b) {
            if (!a || !a.indexOf) {
                return false;
            }
            return a.indexOf(b) !== -1;
        }

        function formlyEval(scope, expression, $modelValue, $viewValue, extraLocals) {
            if (_angularFix2['default'].isFunction(expression)) {
                return expression($viewValue, $modelValue, scope, extraLocals);
            } else {
                return scope.$eval(expression, _angularFix2['default'].extend({ $viewValue: $viewValue, $modelValue: $modelValue }, extraLocals));
            }
        }

        function getFieldId(formId, options, index) {
            if (options.id) {
                return options.id;
            }
            var type = options.type;
            if (!type && options.template) {
                type = 'template';
            } else if (!type && options.templateUrl) {
                type = 'templateUrl';
            }

            return [formId, type, options.key, index].join('_');
        }

        function reverseDeepMerge(dest) {
            _angularFix2['default'].forEach(arguments, function (src, index) {
                if (!index) {
                    return;
                }
                _angularFix2['default'].forEach(src, function (val, prop) {
                    if (!_angularFix2['default'].isDefined(dest[prop])) {
                        dest[prop] = _angularFix2['default'].copy(val);
                    } else if (objAndSameType(dest[prop], val)) {
                        reverseDeepMerge(dest[prop], val);
                    }
                });
            });
            return dest;
        }

        function objAndSameType(obj1, obj2) {
            return _angularFix2['default'].isObject(obj1) && _angularFix2['default'].isObject(obj2) && Object.getPrototypeOf(obj1) === Object.getPrototypeOf(obj2);
        }

        // recurse down a node tree to find a node with matching nodeName, for custom tags jQuery.find doesn't work in IE8
        function findByNodeName(el, nodeName) {
            if (!el.prop) {
                // not a jQuery or jqLite object -> wrap it
                el = _angularFix2['default'].element(el);
            }

            if (el.prop('nodeName') === nodeName.toUpperCase()) {
                return el;
            }

            var c = el.children();
            for (var i = 0; c && i < c.length; i++) {
                var node = findByNodeName(c[i], nodeName);
                if (node) {
                    return node;
                }
            }
        }

        function arrayify(obj) {
            if (obj && !_angularFix2['default'].isArray(obj)) {
                obj = [obj];
            } else if (!obj) {
                obj = [];
            }
            return obj;
        }

        function extendFunction() {
            for (var _len = arguments.length, fns = Array(_len), _key = 0; _key < _len; _key++) {
                fns[_key] = arguments[_key];
            }

            return function extendedFunction() {
                var args = arguments;
                fns.forEach(function (fn) {
                    return fn.apply(null, args);
                });
            };
        }

        function extendArray(primary, secondary, property) {
            if (property) {
                primary = primary[property];
                secondary = secondary[property];
            }
            if (secondary && primary) {
                _angularFix2['default'].forEach(secondary, function (item) {
                    if (primary.indexOf(item) === -1) {
                        primary.push(item);
                    }
                });
                return primary;
            } else if (secondary) {
                return secondary;
            } else {
                return primary;
            }
        }

        function startsWith(str, search) {
            if (_angularFix2['default'].isString(str) && _angularFix2['default'].isString(search)) {
                return str.length >= search.length && str.substring(0, search.length) === search;
            } else {
                return false;
            }
        }

        function contains(str, search) {
            if (_angularFix2['default'].isString(str) && _angularFix2['default'].isString(search)) {
                return str.length >= search.length && str.indexOf(search) !== -1;
            } else {
                return false;
            }
        }
        module.exports = exports['default'];

        /***/
    },
    /* 10 */
    /***/ function (module, exports) {

        'use strict';

        Object.defineProperty(exports, '__esModule', {
            value: true
        });
        exports['default'] = formlyValidationMessages;

        // @ngInject
        function formlyValidationMessages() {

            var validationMessages = {
                addTemplateOptionValueMessage: addTemplateOptionValueMessage,
                addStringMessage: addStringMessage,
                messages: {}
            };

            return validationMessages;

            function addTemplateOptionValueMessage(name, prop, prefix, suffix, alternate) {
                validationMessages.messages[name] = templateOptionValue(prop, prefix, suffix, alternate);
            }

            function addStringMessage(name, string) {
                validationMessages.messages[name] = function () {
                    return string;
                };
            }

            function templateOptionValue(prop, prefix, suffix, alternate) {
                return function getValidationMessage(viewValue, modelValue, scope) {
                    if (typeof scope.options.templateOptions[prop] !== 'undefined') {
                        return prefix + ' ' + scope.options.templateOptions[prop] + ' ' + suffix;
                    } else {
                        return alternate;
                    }
                };
            }
        }
        module.exports = exports['default'];

        /***/
    },
    /* 11 */
    /***/ function (module, exports, __webpack_require__) {

        'use strict';

        Object.defineProperty(exports, '__esModule', {
            value: true
        });

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

        var _otherUtils = __webpack_require__(9);

        var _otherUtils2 = _interopRequireDefault(_otherUtils);

        exports['default'] = formlyUtil;

        // @ngInject
        function formlyUtil() {
            return _otherUtils2['default'];
        }
        module.exports = exports['default'];

        /***/
    },
    /* 12 */
    /***/ function (module, exports) {

        'use strict';

        formlyWarn.$inject = ["formlyConfig", "formlyErrorAndWarningsUrlPrefix", "$log"];
        Object.defineProperty(exports, '__esModule', {
            value: true
        });

        function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length) ; i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }

        exports['default'] = formlyWarn;

        // @ngInject
        function formlyWarn(formlyConfig, formlyErrorAndWarningsUrlPrefix, $log) {
            return function warn() {
                if (!formlyConfig.disableWarnings) {
                    var args = Array.prototype.slice.call(arguments);
                    var warnInfoSlug = args.shift();
                    args.unshift('Formly Warning:');
                    args.push('' + formlyErrorAndWarningsUrlPrefix + warnInfoSlug);
                    $log.warn.apply($log, _toConsumableArray(args));
                }
            };
        }
        module.exports = exports['default'];

        /***/
    },
    /* 13 */
    /***/ function (module, exports, __webpack_require__) {

        'use strict';

        formlyCustomValidation.$inject = ["formlyUtil"];
        Object.defineProperty(exports, '__esModule', {
            value: true
        });

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

        var _angularFix = __webpack_require__(2);

        var _angularFix2 = _interopRequireDefault(_angularFix);

        exports['default'] = formlyCustomValidation;

        // @ngInject
        function formlyCustomValidation(formlyUtil) {
            return {
                restrict: 'A',
                require: 'ngModel',
                link: function formlyCustomValidationLink(scope, el, attrs, ctrl) {
                    var opts = scope.options;
                    opts.validation.messages = opts.validation.messages || {};
                    _angularFix2['default'].forEach(opts.validation.messages, function (message, key) {
                        opts.validation.messages[key] = function () {
                            return formlyUtil.formlyEval(scope, message, ctrl.$modelValue, ctrl.$viewValue);
                        };
                    });

                    var useNewValidatorsApi = ctrl.hasOwnProperty('$validators') && !attrs.hasOwnProperty('useParsers');
                    _angularFix2['default'].forEach(opts.validators, _angularFix2['default'].bind(null, addValidatorToPipeline, false));
                    _angularFix2['default'].forEach(opts.asyncValidators, _angularFix2['default'].bind(null, addValidatorToPipeline, true));

                    function addValidatorToPipeline(isAsync, validator, name) {
                        setupMessage(validator, name);
                        validator = _angularFix2['default'].isObject(validator) ? validator.expression : validator;
                        if (useNewValidatorsApi) {
                            setupWithValidators(validator, name, isAsync);
                        } else {
                            setupWithParsers(validator, name, isAsync);
                        }
                    }

                    function setupMessage(validator, name) {
                        var message = validator.message;
                        if (message) {
                            opts.validation.messages[name] = function () {
                                return formlyUtil.formlyEval(scope, message, ctrl.$modelValue, ctrl.$viewValue);
                            };
                        }
                    }

                    function setupWithValidators(validator, name, isAsync) {
                        var validatorCollection = isAsync ? '$asyncValidators' : '$validators';

                        ctrl[validatorCollection][name] = function evalValidity(modelValue, viewValue) {
                            return formlyUtil.formlyEval(scope, validator, modelValue, viewValue);
                        };
                    }

                    function setupWithParsers(validator, name, isAsync) {
                        var inFlightValidator = undefined;
                        ctrl.$parsers.unshift(function evalValidityOfParser(viewValue) {
                            var isValid = formlyUtil.formlyEval(scope, validator, ctrl.$modelValue, viewValue);
                            if (isAsync) {
                                ctrl.$pending = ctrl.$pending || {};
                                ctrl.$pending[name] = true;
                                inFlightValidator = isValid;
                                isValid.then(function () {
                                    if (inFlightValidator === isValid) {
                                        ctrl.$setValidity(name, true);
                                    }
                                })['catch'](function () {
                                    if (inFlightValidator === isValid) {
                                        ctrl.$setValidity(name, false);
                                    }
                                })['finally'](function () {
                                    var $pending = ctrl.$pending || {};
                                    if (Object.keys($pending).length === 1) {
                                        delete ctrl.$pending;
                                    } else {
                                        delete ctrl.$pending[name];
                                    }
                                });
                            } else {
                                ctrl.$setValidity(name, isValid);
                            }
                            return viewValue;
                        });
                    }
                }
            };
        }
        module.exports = exports['default'];

        /***/
    },
    /* 14 */
    /***/ function (module, exports, __webpack_require__) {

        'use strict';

        formlyField.$inject = ["$http", "$q", "$compile", "$templateCache", "$interpolate", "formlyConfig", "formlyApiCheck", "formlyUtil", "formlyUsability", "formlyWarn"];
        Object.defineProperty(exports, '__esModule', {
            value: true
        });

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

        function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length) ; i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }

        var _angularFix = __webpack_require__(2);

        var _angularFix2 = _interopRequireDefault(_angularFix);

        var _apiCheck = __webpack_require__(5);

        var _apiCheck2 = _interopRequireDefault(_apiCheck);

        exports['default'] = formlyField;

        /**
         * @ngdoc directive
         * @name formlyField
         * @restrict AE
         */
        // @ngInject
        function formlyField($http, $q, $compile, $templateCache, $interpolate, formlyConfig, formlyApiCheck, formlyUtil, formlyUsability, formlyWarn) {
            FormlyFieldController.$inject = ["$scope", "$timeout", "$parse", "$controller", "formlyValidationMessages"];
            var arrayify = formlyUtil.arrayify;

            return {
                restrict: 'AE',
                transclude: true,
                require: '?^formlyForm',
                scope: {
                    options: '=',
                    model: '=',
                    originalModel: '=?',
                    formId: '@', // TODO remove formId in a breaking release
                    index: '=?',
                    fields: '=?',
                    formState: '=?',
                    formOptions: '=?',
                    form: '=?'
                },
                // TODO require form in a breaking release
                controller: FormlyFieldController,
                link: fieldLink
            };

            // @ngInject
            function FormlyFieldController($scope, $timeout, $parse, $controller, formlyValidationMessages) {
                /* eslint max-statements:[2, 34] */
                if ($scope.options.fieldGroup) {
                    setupFieldGroup();
                    return;
                }

                var fieldType = getFieldType($scope.options);
                simplifyLife($scope.options);
                mergeFieldOptionsWithTypeDefaults($scope.options, fieldType);
                extendOptionsWithDefaults($scope.options, $scope.index);
                checkApi($scope.options);
                // set field id to link labels and fields

                // initalization
                setFieldIdAndName();
                setDefaultValue();
                setInitialValue();
                runExpressions();
                watchExpressions();
                addValidationMessages($scope.options);
                invokeControllers($scope, $scope.options, fieldType);

                // function definitions
                function runExpressions() {
                    // must run on next tick to make sure that the current value is correct.
                    return $timeout(function runExpressionsOnNextTick() {
                        var field = $scope.options;
                        var currentValue = valueGetterSetter();
                        _angularFix2['default'].forEach(field.expressionProperties, function runExpression(expression, prop) {
                            var setter = $parse(prop).assign;
                            var promise = $q.when(formlyUtil.formlyEval($scope, expression, currentValue, currentValue));
                            promise.then(function setFieldValue(value) {
                                setter(field, value);
                            });
                        });
                    }, 0, false);
                }

                function watchExpressions() {
                    if ($scope.formOptions.watchAllExpressions) {
                        (function () {
                            var field = $scope.options;
                            var currentValue = valueGetterSetter();
                            _angularFix2['default'].forEach(field.expressionProperties, function watchExpression(expression, prop) {
                                var setter = $parse(prop).assign;
                                $scope.$watch(function expressionPropertyWatcher() {
                                    return formlyUtil.formlyEval($scope, expression, currentValue, currentValue);
                                }, function expressionPropertyListener(value) {
                                    setter(field, value);
                                }, true);
                            });
                        })();
                    }
                }

                function valueGetterSetter(newVal) {
                    if (!$scope.model || !$scope.options.key) {
                        return undefined;
                    }
                    if (_angularFix2['default'].isDefined(newVal)) {
                        parseSet($scope.options.key, $scope.model, newVal);
                    }
                    return parseGet($scope.options.key, $scope.model);
                }

                function shouldNotUseParseKey(key) {
                    return _angularFix2['default'].isNumber(key) || !formlyUtil.containsSelector(key);
                }

                function parseSet(key, model, newVal) {
                    // If either of these are null/undefined then just return undefined
                    if (!key && key !== 0 || !model) {
                        return;
                    }
                    // If we are working with a number then $parse wont work, default back to the old way for now
                    if (shouldNotUseParseKey(key)) {
                        // TODO: Fix this so we can get several levels instead of just one with properties that are numeric
                        model[key] = newVal;
                    } else {
                        var setter = $parse($scope.options.key).assign;
                        if (setter) {
                            setter($scope.model, newVal);
                        }
                    }
                }

                function parseGet(key, model) {
                    // If either of these are null/undefined then just return undefined
                    if (!key && key !== 0 || !model) {
                        return undefined;
                    }

                    // If we are working with a number then $parse wont work, default back to the old way for now
                    if (shouldNotUseParseKey(key)) {
                        // TODO: Fix this so we can get several levels instead of just one with properties that are numeric
                        return model[key];
                    } else {
                        return $parse(key)(model);
                    }
                }

                function simplifyLife(options) {
                    // add a few empty objects (if they don't already exist) so you don't have to undefined check everywhere
                    formlyUtil.reverseDeepMerge(options, {
                        originalModel: options.model,
                        extras: {},
                        data: {},
                        templateOptions: {},
                        validation: {}
                    });
                    // create $scope.to so template authors can reference to instead of $scope.options.templateOptions
                    $scope.to = $scope.options.templateOptions;
                    $scope.formOptions = $scope.formOptions || {};
                }

                function setFieldIdAndName() {
                    if (_angularFix2['default'].isFunction(formlyConfig.extras.getFieldId)) {
                        $scope.id = formlyConfig.extras.getFieldId($scope.options, $scope.model, $scope);
                    } else {
                        var formName = $scope.form && $scope.form.$name || $scope.formId;
                        $scope.id = formlyUtil.getFieldId(formName, $scope.options, $scope.index);
                    }
                    $scope.options.id = $scope.id;
                    $scope.name = $scope.options.name || $scope.options.id;
                    $scope.options.name = $scope.name;
                }

                function setDefaultValue() {
                    if (_angularFix2['default'].isDefined($scope.options.defaultValue) && !_angularFix2['default'].isDefined(parseGet($scope.options.key, $scope.model))) {
                        parseSet($scope.options.key, $scope.model, $scope.options.defaultValue);
                    }
                }

                function setInitialValue() {
                    $scope.options.initialValue = $scope.model && parseGet($scope.options.key, $scope.model);
                }

                function mergeFieldOptionsWithTypeDefaults(options, type) {
                    if (type) {
                        mergeOptions(options, type.defaultOptions);
                    }
                    var properOrder = arrayify(options.optionsTypes).reverse(); // so the right things are overridden
                    _angularFix2['default'].forEach(properOrder, function (typeName) {
                        mergeOptions(options, formlyConfig.getType(typeName, true, options).defaultOptions);
                    });
                }

                function mergeOptions(options, extraOptions) {
                    if (extraOptions) {
                        if (_angularFix2['default'].isFunction(extraOptions)) {
                            extraOptions = extraOptions(options, $scope);
                        }
                        formlyUtil.reverseDeepMerge(options, extraOptions);
                    }
                }

                function extendOptionsWithDefaults(options, index) {
                    var key = options.key || index || 0;
                    _angularFix2['default'].extend(options, {
                        // attach the key in case the formly-field directive is used directly
                        key: key,
                        value: options.value || valueGetterSetter,
                        runExpressions: runExpressions,
                        resetModel: resetModel,
                        updateInitialValue: updateInitialValue
                    });
                }

                function resetModel() {
                    parseSet($scope.options.key, $scope.model, $scope.options.initialValue);
                    if ($scope.options.formControl) {
                        if (_angularFix2['default'].isArray($scope.options.formControl)) {
                            _angularFix2['default'].forEach($scope.options.formControl, function (formControl) {
                                resetFormControl(formControl, true);
                            });
                        } else {
                            resetFormControl($scope.options.formControl);
                        }
                    }
                    if ($scope.form) {
                        $scope.form.$setUntouched && $scope.form.$setUntouched();
                        $scope.form.$setPristine();
                    }
                }

                function resetFormControl(formControl, isMultiNgModel) {
                    if (!isMultiNgModel) {
                        formControl.$setViewValue(parseGet($scope.options.key, $scope.model));
                    }

                    formControl.$render();
                    formControl.$setUntouched && formControl.$setUntouched();
                    formControl.$setPristine();

                    // To prevent breaking change requiring a digest to reset $viewModel
                    if (!$scope.$root.$$phase) {
                        $scope.$digest();
                    }
                }

                function updateInitialValue() {
                    $scope.options.initialValue = parseGet($scope.options.key, $scope.model);
                }

                function addValidationMessages(options) {
                    options.validation.messages = options.validation.messages || {};
                    _angularFix2['default'].forEach(formlyValidationMessages.messages, function createFunctionForMessage(expression, name) {
                        if (!options.validation.messages[name]) {
                            options.validation.messages[name] = function evaluateMessage(viewValue, modelValue, scope) {
                                return formlyUtil.formlyEval(scope, expression, modelValue, viewValue);
                            };
                        }
                    });
                }

                function invokeControllers(scope) {
                    var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
                    var type = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];

                    _angularFix2['default'].forEach([type.controller, options.controller], function (controller) {
                        if (controller) {
                            $controller(controller, { $scope: scope });
                        }
                    });
                }

                function setupFieldGroup() {
                    $scope.options.options = $scope.options.options || {};
                    $scope.options.options.formState = $scope.formState;
                    $scope.to = $scope.options.templateOptions;
                }
            }

            // link function
            function fieldLink(scope, el, attrs, formlyFormCtrl) {
                if (scope.options.fieldGroup) {
                    setFieldGroupTemplate();
                    return;
                }

                // watch the field model (if exists) if there is no parent formly-form directive (that would watch it instead)
                if (!formlyFormCtrl && scope.options.model) {
                    scope.$watch('options.model', function () {
                        return scope.options.runExpressions();
                    }, true);
                }

                addAttributes();
                addClasses();

                var type = getFieldType(scope.options);
                var args = arguments;
                var thusly = this;
                var fieldCount = 0;
                var fieldManipulators = getManipulators(scope.options, scope.formOptions);
                getFieldTemplate(scope.options).then(runManipulators(fieldManipulators.preWrapper)).then(transcludeInWrappers(scope.options, scope.formOptions)).then(runManipulators(fieldManipulators.postWrapper)).then(setElementTemplate).then(watchFormControl).then(callLinkFunctions)['catch'](function (error) {
                    formlyWarn('there-was-a-problem-setting-the-template-for-this-field', 'There was a problem setting the template for this field ', scope.options, error);
                });

                function setFieldGroupTemplate() {
                    checkFieldGroupApi(scope.options);
                    el.addClass('formly-field-group');
                    var extraAttributes = '';
                    if (scope.options.elementAttributes) {
                        extraAttributes = Object.keys(scope.options.elementAttributes).map(function (key) {
                            return key + '="' + scope.options.elementAttributes[key] + '"';
                        }).join(' ');
                    }
                    var modelValue = 'model';
                    scope.options.form = scope.form;
                    if (scope.options.key) {
                        modelValue = 'model[\'' + scope.options.key + '\']';
                    }
                    getTemplate('\n          <formly-form model="' + modelValue + '"\n                       fields="options.fieldGroup"\n                       options="options.options"\n                       form="options.form"\n                       class="' + scope.options.className + '"\n                       ' + extraAttributes + '\n                       is-field-group>\n          </formly-form>\n        ').then(transcludeInWrappers(scope.options, scope.formOptions)).then(setElementTemplate);
                }

                function addAttributes() {
                    if (scope.options.elementAttributes) {
                        el.attr(scope.options.elementAttributes);
                    }
                }

                function addClasses() {
                    if (scope.options.className) {
                        el.addClass(scope.options.className);
                    }
                    if (scope.options.type) {
                        el.addClass('formly-field-' + scope.options.type);
                    }
                }

                function setElementTemplate(templateString) {
                    el.html(asHtml(templateString));
                    $compile(el.contents())(scope);
                    return templateString;
                }

                function watchFormControl(templateString) {
                    var stopWatchingShowError = _angularFix2['default'].noop;
                    if (scope.options.noFormControl) {
                        return;
                    }
                    var templateEl = _angularFix2['default'].element('<div>' + templateString + '</div>');
                    var ngModelNodes = templateEl[0].querySelectorAll('[ng-model],[data-ng-model]');

                    if (ngModelNodes.length) {
                        _angularFix2['default'].forEach(ngModelNodes, function (ngModelNode) {
                            fieldCount++;
                            watchFieldNameOrExistence(ngModelNode.getAttribute('name'));
                        });
                    }

                    function watchFieldNameOrExistence(name) {
                        var nameExpressionRegex = /\{\{(.*?)}}/;
                        var nameExpression = nameExpressionRegex.exec(name);
                        if (nameExpression) {
                            name = $interpolate(name)(scope);
                        }
                        watchFieldExistence(name);
                    }

                    function watchFieldExistence(name) {
                        scope.$watch('form["' + name + '"]', function formControlChange(formControl) {
                            if (formControl) {
                                if (fieldCount > 1) {
                                    if (!scope.options.formControl) {
                                        scope.options.formControl = [];
                                    }
                                    scope.options.formControl.push(formControl);
                                } else {
                                    scope.options.formControl = formControl;
                                }
                                scope.fc = scope.options.formControl; // shortcut for template authors
                                stopWatchingShowError();
                                addShowMessagesWatcher();
                                addParsers();
                                addFormatters();
                            }
                        });
                    }

                    function addShowMessagesWatcher() {
                        stopWatchingShowError = scope.$watch(function watchShowValidationChange() {
                            var customExpression = formlyConfig.extras.errorExistsAndShouldBeVisibleExpression;
                            var options = scope.options;
                            var formControls = arrayify(scope.fc);
                            if (!formControls.some(function (fc) {
                              return fc.$invalid;
                            })) {
                                return false;
                            } else if (typeof options.validation.show === 'boolean') {
                                return options.validation.show;
                            } else if (customExpression) {
                                return formControls.some(function (fc) {
                                    return formlyUtil.formlyEval(scope, customExpression, fc.$modelValue, fc.$viewValue);
                                });
                            } else {
                                return formControls.some(function (fc) {
                                    var noTouchedButDirty = _angularFix2['default'].isUndefined(fc.$touched) && fc.$dirty;
                                    return fc.$touched || noTouchedButDirty;
                                });
                            }
                        }, function onShowValidationChange(show) {
                            scope.options.validation.errorExistsAndShouldBeVisible = show;
                            scope.showError = show; // shortcut for template authors
                        });
                    }

                    function addParsers() {
                        setParsersOrFormatters('parsers');
                    }

                    function addFormatters() {
                        setParsersOrFormatters('formatters');
                        var ctrl = scope.fc;
                        var formWasPristine = scope.form.$pristine;
                        if (scope.options.formatters) {
                            (function () {
                                var value = ctrl.$modelValue;
                                ctrl.$formatters.forEach(function (formatter) {
                                    value = formatter(value);
                                });

                                ctrl.$setViewValue(value);
                                ctrl.$render();
                                ctrl.$setPristine();
                                if (formWasPristine) {
                                    scope.form.$setPristine();
                                }
                            })();
                        }
                    }

                    function setParsersOrFormatters(which) {
                        var originalThingProp = 'originalParser';
                        if (which === 'formatters') {
                            originalThingProp = 'originalFormatter';
                        }

                        // init with type's parsers
                        var things = getThingsFromType(type);

                        // get optionsTypes things
                        things = formlyUtil.extendArray(things, getThingsFromOptionsTypes(scope.options.optionsTypes));

                        // get field's things
                        things = formlyUtil.extendArray(things, scope.options[which]);

                        // convert things into formlyExpression things
                        _angularFix2['default'].forEach(things, function (thing, index) {
                            things[index] = getFormlyExpressionThing(thing);
                        });

                        var ngModelCtrls = scope.fc;
                        if (!_angularFix2['default'].isArray(ngModelCtrls)) {
                            ngModelCtrls = [ngModelCtrls];
                        }

                        _angularFix2['default'].forEach(ngModelCtrls, function (ngModelCtrl) {
                            var _ngModelCtrl;

                            ngModelCtrl['$' + which] = (_ngModelCtrl = ngModelCtrl['$' + which]).concat.apply(_ngModelCtrl, _toConsumableArray(things));
                        });

                        function getThingsFromType(theType) {
                            if (!theType) {
                                return [];
                            }
                            if (_angularFix2['default'].isString(theType)) {
                                theType = formlyConfig.getType(theType, true, scope.options);
                            }
                            var typeThings = [];

                            // get things from parent
                            if (theType['extends']) {
                                typeThings = formlyUtil.extendArray(typeThings, getThingsFromType(theType['extends']));
                            }

                            // get own type's things
                            typeThings = formlyUtil.extendArray(typeThings, getDefaultOptionsProperty(theType, which, []));

                            // get things from optionsTypes
                            typeThings = formlyUtil.extendArray(typeThings, getThingsFromOptionsTypes(getDefaultOptionsOptionsTypes(theType)));

                            return typeThings;
                        }

                        function getThingsFromOptionsTypes() {
                            var optionsTypes = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];

                            var optionsTypesThings = [];
                            _angularFix2['default'].forEach(_angularFix2['default'].copy(arrayify(optionsTypes)).reverse(), function (optionsTypeName) {
                                optionsTypesThings = formlyUtil.extendArray(optionsTypesThings, getThingsFromType(optionsTypeName));
                            });
                            return optionsTypesThings;
                        }

                        function getFormlyExpressionThing(thing) {
                            formlyExpressionParserOrFormatterFunction[originalThingProp] = thing;
                            return formlyExpressionParserOrFormatterFunction;

                            function formlyExpressionParserOrFormatterFunction($viewValue) {
                                var $modelValue = scope.options.value();
                                return formlyUtil.formlyEval(scope, thing, $modelValue, $viewValue);
                            }
                        }
                    }
                }

                function callLinkFunctions() {
                    if (type && type.link) {
                        type.link.apply(thusly, args);
                    }
                    if (scope.options.link) {
                        scope.options.link.apply(thusly, args);
                    }
                }

                function runManipulators(manipulators) {
                    return function runManipulatorsOnTemplate(templateToManipulate) {
                        var chain = $q.when(templateToManipulate);
                        _angularFix2['default'].forEach(manipulators, function (manipulator) {
                            chain = chain.then(function (template) {
                                return $q.when(manipulator(template, scope.options, scope)).then(function (newTemplate) {
                                    return _angularFix2['default'].isString(newTemplate) ? newTemplate : asHtml(newTemplate);
                                });
                            });
                        });
                        return chain;
                    };
                }
            }

            // sort-of stateless util functions
            function asHtml(el) {
                var wrapper = _angularFix2['default'].element('<a></a>');
                return wrapper.append(el).html();
            }

            function getFieldType(options) {
                return options.type && formlyConfig.getType(options.type);
            }

            function getManipulators(options, formOptions) {
                var preWrapper = [];
                var postWrapper = [];
                addManipulators(options.templateManipulators);
                addManipulators(formOptions.templateManipulators);
                addManipulators(formlyConfig.templateManipulators);
                return { preWrapper: preWrapper, postWrapper: postWrapper };

                function addManipulators(manipulators) {
                    /* eslint-disable */ // it doesn't understand this :-(

                    var _ref = manipulators || {};

                    var _ref$preWrapper = _ref.preWrapper;
                    var pre = _ref$preWrapper === undefined ? [] : _ref$preWrapper;
                    var _ref$postWrapper = _ref.postWrapper;
                    var post = _ref$postWrapper === undefined ? [] : _ref$postWrapper;

                    preWrapper = preWrapper.concat(pre);
                    postWrapper = postWrapper.concat(post);
                    /* eslint-enable */
                }
            }

            function getFieldTemplate(options) {
                function fromOptionsOrType(key, fieldType) {
                    if (_angularFix2['default'].isDefined(options[key])) {
                        return options[key];
                    } else if (fieldType && _angularFix2['default'].isDefined(fieldType[key])) {
                        return fieldType[key];
                    }
                }

                var type = formlyConfig.getType(options.type, true, options);
                var template = fromOptionsOrType('template', type);
                var templateUrl = fromOptionsOrType('templateUrl', type);
                if (_angularFix2['default'].isUndefined(template) && !templateUrl) {
                    throw formlyUsability.getFieldError('type-type-has-no-template', 'Type \'' + options.type + '\' has no template. On element:', options);
                }

                return getTemplate(templateUrl || template, _angularFix2['default'].isUndefined(template), options);
            }

            function getTemplate(template, isUrl, options) {
                var templatePromise = undefined;
                if (_angularFix2['default'].isFunction(template)) {
                    templatePromise = $q.when(template(options));
                } else {
                    templatePromise = $q.when(template);
                }

                if (!isUrl) {
                    return templatePromise;
                } else {
                    var _ret3 = (function () {
                        var httpOptions = { cache: $templateCache };
                        return {
                            v: templatePromise.then(function (url) {
                                return $http.get(url, httpOptions);
                            }).then(function (response) {
                                return response.data;
                            })['catch'](function handleErrorGettingATemplate(error) {
                                formlyWarn('problem-loading-template-for-templateurl', 'Problem loading template for ' + template, error);
                            })
                        };
                    })();

                    if (typeof _ret3 === 'object') return _ret3.v;
                }
            }

            function transcludeInWrappers(options, formOptions) {
                var wrapper = getWrapperOption(options, formOptions);

                return function transcludeTemplate(template) {
                    if (!wrapper.length) {
                        return $q.when(template);
                    }

                    wrapper.forEach(function (aWrapper) {
                        formlyUsability.checkWrapper(aWrapper, options);
                        runApiCheck(aWrapper, options);
                    });
                    var promises = wrapper.map(function (w) {
                        return getTemplate(w.template || w.templateUrl, !w.template);
                    });
                    return $q.all(promises).then(function (wrappersTemplates) {
                        wrappersTemplates.forEach(function (wrapperTemplate, index) {
                            formlyUsability.checkWrapperTemplate(wrapperTemplate, wrapper[index]);
                        });
                        wrappersTemplates.reverse(); // wrapper 0 is wrapped in wrapper 1 and so on...
                        var totalWrapper = wrappersTemplates.shift();
                        wrappersTemplates.forEach(function (wrapperTemplate) {
                            totalWrapper = doTransclusion(totalWrapper, wrapperTemplate);
                        });
                        return doTransclusion(totalWrapper, template);
                    });
                };
            }

            function doTransclusion(wrapper, template) {
                var superWrapper = _angularFix2['default'].element('<a></a>'); // this allows people not have to have a single root in wrappers
                superWrapper.append(wrapper);
                var transcludeEl = superWrapper.find('formly-transclude');
                if (!transcludeEl.length) {
                    // try it using our custom find function
                    transcludeEl = formlyUtil.findByNodeName(superWrapper, 'formly-transclude');
                }
                transcludeEl.replaceWith(template);
                return superWrapper.html();
            }

            function getWrapperOption(options, formOptions) {
                /* eslint complexity:[2, 6] */
                var wrapper = options.wrapper;
                // explicit null means no wrapper
                if (wrapper === null) {
                    return [];
                }

                // nothing specified means use the default wrapper for the type
                if (!wrapper) {
                    // get all wrappers that specify they apply to this type
                    wrapper = arrayify(formlyConfig.getWrapperByType(options.type));
                } else {
                    wrapper = arrayify(wrapper).map(formlyConfig.getWrapper);
                }

                // get all wrappers for that the type specified that it uses.
                var type = formlyConfig.getType(options.type, true, options);
                if (type && type.wrapper) {
                    var typeWrappers = arrayify(type.wrapper).map(formlyConfig.getWrapper);
                    wrapper = wrapper.concat(typeWrappers);
                }

                // add form wrappers
                if (formOptions.wrapper) {
                    var formWrappers = arrayify(formOptions.wrapper).map(formlyConfig.getWrapper);
                    wrapper = wrapper.concat(formWrappers);
                }

                // add the default wrapper last
                var defaultWrapper = formlyConfig.getWrapper();
                if (defaultWrapper) {
                    wrapper.push(defaultWrapper);
                }
                return wrapper;
            }

            function checkApi(options) {
                formlyApiCheck['throw'](formlyApiCheck.formlyFieldOptions, options, {
                    prefix: 'formly-field directive',
                    url: 'formly-field-directive-validation-failed'
                });
                // validate with the type
                var type = options.type && formlyConfig.getType(options.type);
                if (type) {
                    runApiCheck(type, options, true);
                }
                if (options.expressionProperties && options.expressionProperties.hide) {
                    formlyWarn('dont-use-expressionproperties.hide-use-hideexpression-instead', 'You have specified `hide` in `expressionProperties`. Use `hideExpression` instead', options);
                }
            }

            function checkFieldGroupApi(options) {
                formlyApiCheck['throw'](formlyApiCheck.fieldGroup, options, {
                    prefix: 'formly-field directive',
                    url: 'formly-field-directive-validation-failed'
                });
            }

            function runApiCheck(_ref2, options, forType) {
                var apiCheck = _ref2.apiCheck;
                var apiCheckInstance = _ref2.apiCheckInstance;
                var apiCheckFunction = _ref2.apiCheckFunction;
                var apiCheckOptions = _ref2.apiCheckOptions;

                runApiCheckForType(apiCheck, apiCheckInstance, apiCheckFunction, apiCheckOptions, options);
                if (forType && options.type) {
                    _angularFix2['default'].forEach(formlyConfig.getTypeHeritage(options.type), function (type) {
                        runApiCheckForType(type.apiCheck, type.apiCheckInstance, type.apiCheckFunction, type.apiCheckOptions, options);
                    });
                }
            }

            function runApiCheckForType(apiCheck, apiCheckInstance, apiCheckFunction, apiCheckOptions, options) {
                /* eslint complexity:[2, 9] */
                if (!apiCheck) {
                    return;
                }
                var instance = apiCheckInstance || formlyConfig.extras.apiCheckInstance || formlyApiCheck;
                if (instance.config.disabled || _apiCheck2['default'].globalConfig.disabled) {
                    return;
                }
                var fn = apiCheckFunction || 'warn';
                // this is the new API
                var checkerObjects = apiCheck(instance);
                _angularFix2['default'].forEach(checkerObjects, function (shape, name) {
                    var checker = instance.shape(shape);
                    var checkOptions = _angularFix2['default'].extend({
                        prefix: 'formly-field type ' + options.type + ' for property ' + name,
                        url: formlyApiCheck.config.output.docsBaseUrl + 'formly-field-type-apicheck-failed'
                    }, apiCheckOptions);
                    instance[fn](checker, options[name], checkOptions);
                });
            }
        }

        // Stateless util functions
        function getDefaultOptionsOptionsTypes(type) {
            return getDefaultOptionsProperty(type, 'optionsTypes', []);
        }

        function getDefaultOptionsProperty(type, prop, defaultValue) {
            return type.defaultOptions && type.defaultOptions[prop] || defaultValue;
        }
        module.exports = exports['default'];

        /***/
    },
    /* 15 */
    /***/ function (module, exports) {

        'use strict';

        formlyFocus.$inject = ["$timeout", "$document"];
        Object.defineProperty(exports, '__esModule', {
            value: true
        });
        exports['default'] = formlyFocus;

        // @ngInject
        function formlyFocus($timeout, $document) {
            return {
                restrict: 'A',
                link: function formlyFocusLink(scope, element, attrs) {
                    var previousEl = null;
                    var el = element[0];
                    var doc = $document[0];
                    attrs.$observe('formlyFocus', function respondToFocusExpressionChange(value) {
                        /* eslint no-bitwise:0 */ // I know what I'm doing. I promise...
                        if (value === 'true') {
                            $timeout(function setElementFocus() {
                                previousEl = doc.activeElement;
                                el.focus();
                            }, ~ ~attrs.focusWait);
                        } else if (value === 'false') {
                            if (doc.activeElement === el) {
                                el.blur();
                                if (attrs.hasOwnProperty('refocus') && previousEl) {
                                    previousEl.focus();
                                }
                            }
                        }
                    });
                }
            };
        }
        module.exports = exports['default'];

        /***/
    },
    /* 16 */
    /***/ function (module, exports, __webpack_require__) {

        'use strict';

        formlyForm.$inject = ["formlyUsability", "formlyWarn", "$parse", "formlyConfig", "$interpolate"];
        Object.defineProperty(exports, '__esModule', {
            value: true
        });

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

        var _angularFix = __webpack_require__(2);

        var _angularFix2 = _interopRequireDefault(_angularFix);

        exports['default'] = formlyForm;

        /**
         * @ngdoc directive
         * @name formlyForm
         * @restrict AE
         */
        // @ngInject
        function formlyForm(formlyUsability, formlyWarn, $parse, formlyConfig, $interpolate) {
            var currentFormId = 1;
            return {
                restrict: 'AE',
                template: formlyFormGetTemplate,
                replace: true,
                transclude: true,
                scope: {
                    fields: '=',
                    model: '=',
                    form: '=?',
                    options: '=?'
                },
                controller: 'FormlyFormController',
                link: formlyFormLink
            };

            function formlyFormGetTemplate(el, attrs) {
                var rootEl = getRootEl();
                var fieldRootEl = getFieldRootEl();
                var formId = 'formly_' + currentFormId++;
                var parentFormAttributes = '';
                if (attrs.hasOwnProperty('isFieldGroup') && el.parent().parent().hasClass('formly')) {
                    parentFormAttributes = copyAttributes(el.parent().parent()[0].attributes);
                }
                return '\n        <' + rootEl + ' class="formly"\n                 name="' + getFormName() + '"\n                 role="form" ' + parentFormAttributes + '>\n          <' + fieldRootEl + ' formly-field\n               ng-repeat="field in fields ' + getTrackBy() + '"\n               ' + getHideDirective() + '="!field.hide"\n               class="formly-field"\n               options="field"\n               model="field.model || model"\n               original-model="model"\n               fields="fields"\n               form="theFormlyForm"\n               form-id="' + getFormName() + '"\n               form-state="options.formState"\n               form-options="options"\n               index="$index">\n          </' + fieldRootEl + '>\n          <div ng-transclude class="' + getTranscludeClass() + '"></div>\n        </' + rootEl + '>\n      ';

                function getRootEl() {
                    return attrs.rootEl || 'ng-form';
                }

                function getFieldRootEl() {
                    return attrs.fieldRootEl || 'div';
                }

                function getHideDirective() {
                    return attrs.hideDirective || formlyConfig.extras.defaultHideDirective || 'ng-if';
                }

                function getTrackBy() {
                    if (!attrs.trackBy) {
                        return '';
                    } else {
                        return 'track by ' + attrs.trackBy;
                    }
                }

                function getFormName() {
                    var formName = formId;
                    var bindName = attrs.bindName;
                    if (bindName) {
                        if (_angularFix2['default'].version.minor < 3) {
                            throw formlyUsability.getFormlyError('bind-name attribute on formly-form not allowed in < angular 1.3');
                        }
                        // we can do a one-time binding here because we know we're in 1.3.x territory
                        formName = $interpolate.startSymbol() + '::\'formly_\' + ' + bindName + $interpolate.endSymbol();
                    }
                    return formName;
                }

                function getTranscludeClass() {
                    return attrs.transcludeClass || '';
                }

                function copyAttributes(attributes) {
                    var excluded = ['model', 'form', 'fields', 'options', 'name', 'role', 'class', 'data-model', 'data-form', 'data-fields', 'data-options', 'data-name'];
                    var arrayAttrs = [];
                    _angularFix2['default'].forEach(attributes, function (_ref) {
                        var nodeName = _ref.nodeName;
                        var value = _ref.value;

                        if (nodeName !== 'undefined' && excluded.indexOf(nodeName) === -1) {
                            arrayAttrs.push(toKebabCase(nodeName) + '="' + value + '"');
                        }
                    });
                    return arrayAttrs.join(' ');
                }
            }

            function formlyFormLink(scope, el, attrs) {
                setFormController();
                fixChromeAutocomplete();

                function setFormController() {
                    var formId = attrs.name;
                    scope.formId = formId;
                    scope.theFormlyForm = scope[formId];
                    if (attrs.form) {
                        var getter = $parse(attrs.form);
                        var setter = getter.assign;
                        var parentForm = getter(scope.$parent);
                        if (parentForm) {
                            scope.theFormlyForm = parentForm;
                            if (scope[formId]) {
                                scope.theFormlyForm.$removeControl(scope[formId]);
                            }

                            // this next line is probably one of the more dangerous things that angular-formly does to improve the
                            // API for angular-formly forms. It ensures that the NgModelControllers inside of formly-form will be
                            // attached to the form that is passed to formly-form rather than the one that formly-form creates
                            // this is necessary because it's confusing to have a step between the form you pass in
                            // and the fields in that form. It also is because angular doesn't propagate properties like $submitted down
                            // to children forms :-( This line was added to solve this issue:
                            // https://github.com/formly-js/angular-formly/issues/287
                            // luckily, this is how the formController has been accessed by the NgModelController since angular 1.0.0
                            // so I expect it will remain this way for the life of angular 1.x
                            el.removeData('$formController');
                        } else {
                            setter(scope.$parent, scope[formId]);
                        }
                    }
                    if (!scope.theFormlyForm && !formlyConfig.disableWarnings) {
                        /* eslint no-console:0 */
                        formlyWarn('formly-form-has-no-formcontroller', 'Your formly-form does not have a `form` property. Many functions of the form (like validation) may not work', el, scope);
                    }
                }

                /*
                 * chrome autocomplete lameness
                 * see https://code.google.com/p/chromium/issues/detail?id=468153#c14
                 * ლ(ಠ益ಠლ)   (╯°□°)╯︵ ┻━┻    (◞‸◟；)
                 */
                function fixChromeAutocomplete() {
                    var global = formlyConfig.extras.removeChromeAutoComplete === true;
                    var offInstance = scope.options && scope.options.removeChromeAutoComplete === false;
                    var onInstance = scope.options && scope.options.removeChromeAutoComplete === true;
                    if (global && !offInstance || onInstance) {
                        var input = document.createElement('input');
                        input.setAttribute('autocomplete', 'address-level4');
                        input.setAttribute('hidden', 'true');
                        el[0].appendChild(input);
                    }
                }
            }

            // stateless util functions
            function toKebabCase(string) {
                if (string) {
                    return string.replace(/([A-Z])/g, function ($1) {
                        return '-' + $1.toLowerCase();
                    });
                } else {
                    return '';
                }
            }
        }
        module.exports = exports['default'];

        /***/
    },
    /* 17 */
    /***/ function (module, exports, __webpack_require__) {

        'use strict';

        FormlyFormController.$inject = ["formlyUsability", "formlyWarn", "formlyConfig", "$parse", "$scope", "formlyApiCheck", "formlyUtil"];
        Object.defineProperty(exports, '__esModule', {
            value: true
        });
        var _slice = Array.prototype.slice;
        exports['default'] = FormlyFormController;

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

        function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length) ; i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }

        var _angularFix = __webpack_require__(2);

        var _angularFix2 = _interopRequireDefault(_angularFix);

        function isFieldGroup(field) {
            return field && !!field.fieldGroup;
        }

        // @ngInject

        function FormlyFormController(formlyUsability, formlyWarn, formlyConfig, $parse, $scope, formlyApiCheck, formlyUtil) {

            setupOptions();
            $scope.model = $scope.model || {};
            setupFields();

            // watch the model and evaluate watch expressions that depend on it.
            if (!$scope.options.manualModelWatcher) {
                $scope.$watch('model', onModelOrFormStateChange, true);
            } else if (_angularFix2['default'].isFunction($scope.options.manualModelWatcher)) {
                $scope.$watch($scope.options.manualModelWatcher, onModelOrFormStateChange, true);
            }

            if ($scope.options.formState) {
                $scope.$watch('options.formState', onModelOrFormStateChange, true);
            }

            function onModelOrFormStateChange() {
                _angularFix2['default'].forEach($scope.fields, runFieldExpressionProperties);
            }

            function validateFormControl(formControl, promise) {
                var validate = formControl.$validate;
                if (promise) {
                    promise.then(validate);
                } else {
                    validate();
                }
            }

            function runFieldExpressionProperties(field, index) {
                var model = field.model || $scope.model;
                var promise = field.runExpressions && field.runExpressions();
                if (field.hideExpression) {
                    // can't use hide with expressionProperties reliably
                    var val = model[field.key];
                    field.hide = evalCloseToFormlyExpression(field.hideExpression, val, field, index, { model: model });
                }
                if (field.extras && field.extras.validateOnModelChange && field.formControl) {
                    if (_angularFix2['default'].isArray(field.formControl)) {
                        _angularFix2['default'].forEach(field.formControl, function (formControl) {
                            validateFormControl(formControl, promise);
                        });
                    } else {
                        validateFormControl(field.formControl, promise);
                    }
                }
            }

            function setupFields() {
                $scope.fields = $scope.fields || [];

                checkDeprecatedOptions($scope.options);

                var fieldTransforms = $scope.options.fieldTransform || formlyConfig.extras.fieldTransform;

                if (!_angularFix2['default'].isArray(fieldTransforms)) {
                    fieldTransforms = [fieldTransforms];
                }

                _angularFix2['default'].forEach(fieldTransforms, function transformFields(fieldTransform) {
                    if (fieldTransform) {
                        $scope.fields = fieldTransform($scope.fields, $scope.model, $scope.options, $scope.form);
                        if (!$scope.fields) {
                            throw formlyUsability.getFormlyError('fieldTransform must return an array of fields');
                        }
                    }
                });

                setupModels();

                if ($scope.options.watchAllExpressions) {
                    _angularFix2['default'].forEach($scope.fields, setupHideExpressionWatcher);
                }

                _angularFix2['default'].forEach($scope.fields, attachKey); // attaches a key based on the index if a key isn't specified
                _angularFix2['default'].forEach($scope.fields, setupWatchers); // setup watchers for all fields
            }

            function checkDeprecatedOptions(options) {
                if (formlyConfig.extras.fieldTransform && _angularFix2['default'].isFunction(formlyConfig.extras.fieldTransform)) {
                    formlyWarn('fieldtransform-as-a-function-deprecated', 'fieldTransform as a function has been deprecated.', 'Attempted for formlyConfig.extras: ' + formlyConfig.extras.fieldTransform.name, formlyConfig.extras);
                } else if (options.fieldTransform && _angularFix2['default'].isFunction(options.fieldTransform)) {
                    formlyWarn('fieldtransform-as-a-function-deprecated', 'fieldTransform as a function has been deprecated.', 'Attempted for form', options);
                }
            }

            function setupOptions() {
                formlyApiCheck['throw']([formlyApiCheck.formOptionsApi.optional], [$scope.options], { prefix: 'formly-form options check' });
                $scope.options = $scope.options || {};
                $scope.options.formState = $scope.options.formState || {};

                _angularFix2['default'].extend($scope.options, {
                    updateInitialValue: updateInitialValue,
                    resetModel: resetModel
                });
            }

            function updateInitialValue() {
                _angularFix2['default'].forEach($scope.fields, function (field) {
                    if (isFieldGroup(field) && field.options) {
                        field.options.updateInitialValue();
                    } else {
                        field.updateInitialValue();
                    }
                });
            }

            function resetModel() {
                _angularFix2['default'].forEach($scope.fields, function (field) {
                    if (isFieldGroup(field) && field.options) {
                        field.options.resetModel();
                    } else if (field.resetModel) {
                        field.resetModel();
                    }
                });
            }

            function setupModels() {
                // a set of field models that are already watched (the $scope.model will have its own watcher)
                var watchedModels = [$scope.model];
                // we will not set up automatic model watchers if manual mode is set
                var manualModelWatcher = $scope.options.manualModelWatcher;

                if ($scope.options.formState) {
                    // $scope.options.formState will have its own watcher
                    watchedModels.push($scope.options.formState);
                }

                _angularFix2['default'].forEach($scope.fields, function (field) {
                    var isNewModel = initModel(field);

                    if (field.model && isNewModel && watchedModels.indexOf(field.model) === -1 && !manualModelWatcher) {
                        $scope.$watch(function () {
                            return field.model;
                        }, onModelOrFormStateChange, true);
                        watchedModels.push(field.model);
                    }
                });
            }

            function setupHideExpressionWatcher(field, index) {
                if (field.hideExpression) {
                    (function () {
                        // can't use hide with expressionProperties reliably
                        var model = field.model || $scope.model;
                        $scope.$watch(function hideExpressionWatcher() {
                            var val = model[field.key];
                            return evalCloseToFormlyExpression(field.hideExpression, val, field, index, { model: model });
                        }, function (hide) {
                            return field.hide = hide;
                        }, true);
                    })();
                }
            }

            function initModel(field) {
                var isNewModel = true;

                if (_angularFix2['default'].isString(field.model)) {
                    (function () {
                        var expression = field.model;

                        isNewModel = !referencesCurrentlyWatchedModel(expression);

                        field.model = resolveStringModel(expression);

                        $scope.$watch(function () {
                            return resolveStringModel(expression);
                        }, function (model) {
                            return field.model = model;
                        });
                    })();
                }

                return isNewModel;

                function resolveStringModel(expression) {
                    var index = $scope.fields.indexOf(field);
                    var model = evalCloseToFormlyExpression(expression, undefined, field, index, { model: $scope.model });

                    if (!model) {
                        throw formlyUsability.getFieldError('field-model-must-be-initialized', 'Field model must be initialized. When specifying a model as a string for a field, the result of the' + ' expression must have been initialized ahead of time.', field);
                    }

                    return model;
                }
            }

            function referencesCurrentlyWatchedModel(expression) {
                return ['model', 'formState'].some(function (item) {
                    return formlyUtil.startsWith(expression, item + '.') || formlyUtil.startsWith(expression, item + '[');
                });
            }

            function attachKey(field, index) {
                if (!isFieldGroup(field)) {
                    field.key = field.key || index || 0;
                }
            }

            function setupWatchers(field, index) {
                if (!_angularFix2['default'].isDefined(field.watcher)) {
                    return;
                }
                var watchers = field.watcher;
                if (!_angularFix2['default'].isArray(watchers)) {
                    watchers = [watchers];
                }
                _angularFix2['default'].forEach(watchers, function setupWatcher(watcher) {
                    if (!_angularFix2['default'].isDefined(watcher.listener) && !watcher.runFieldExpressions) {
                        throw formlyUsability.getFieldError('all-field-watchers-must-have-a-listener', 'All field watchers must have a listener', field);
                    }
                    var watchExpression = getWatchExpression(watcher, field, index);
                    var watchListener = getWatchListener(watcher, field, index);

                    var type = watcher.type || '$watch';
                    watcher.stopWatching = $scope[type](watchExpression, watchListener, watcher.watchDeep);
                });
            }

            function getWatchExpression(watcher, field, index) {
                var watchExpression = undefined;
                if (!_angularFix2['default'].isUndefined(watcher.expression)) {
                    watchExpression = watcher.expression;
                } else if (field.key) {
                    watchExpression = 'model[\'' + field.key.toString().split('.').join('\'][\'') + '\']';
                }
                if (_angularFix2['default'].isFunction(watchExpression)) {
                    (function () {
                        // wrap the field's watch expression so we can call it with the field as the first arg
                        // and the stop function as the last arg as a helper
                        var originalExpression = watchExpression;
                        watchExpression = function formlyWatchExpression() {
                            var args = modifyArgs.apply(undefined, [watcher, index].concat(_slice.call(arguments)));
                            return originalExpression.apply(undefined, _toConsumableArray(args));
                        };
                        watchExpression.displayName = 'Formly Watch Expression for field for ' + field.key;
                    })();
                } else if (field.model) {
                    watchExpression = $parse(watchExpression).bind(null, $scope, { model: field.model });
                }
                return watchExpression;
            }

            function getWatchListener(watcher, field, index) {
                var watchListener = watcher.listener;
                if (_angularFix2['default'].isFunction(watchListener) || watcher.runFieldExpressions) {
                    (function () {
                        // wrap the field's watch listener so we can call it with the field as the first arg
                        // and the stop function as the last arg as a helper
                        var originalListener = watchListener;
                        watchListener = function formlyWatchListener() {
                            var value = undefined;
                            if (originalListener) {
                                var args = modifyArgs.apply(undefined, [watcher, index].concat(_slice.call(arguments)));
                                value = originalListener.apply(undefined, _toConsumableArray(args));
                            }
                            if (watcher.runFieldExpressions) {
                                runFieldExpressionProperties(field, index);
                            }
                            return value;
                        };
                        watchListener.displayName = 'Formly Watch Listener for field for ' + field.key;
                    })();
                }
                return watchListener;
            }

            function modifyArgs(watcher, index) {
                for (var _len = arguments.length, originalArgs = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
                    originalArgs[_key - 2] = arguments[_key];
                }

                return [$scope.fields[index]].concat(originalArgs, [watcher.stopWatching]);
            }

            function evalCloseToFormlyExpression(expression, val, field, index) {
                var extraLocals = arguments.length <= 4 || arguments[4] === undefined ? {} : arguments[4];

                extraLocals = _angularFix2['default'].extend(getFormlyFieldLikeLocals(field, index), extraLocals);
                return formlyUtil.formlyEval($scope, expression, val, val, extraLocals);
            }

            function getFormlyFieldLikeLocals(field, index) {
                // this makes it closer to what a regular formlyExpression would be
                return {
                    model: field.model,
                    options: field,
                    index: index,
                    formState: $scope.options.formState,
                    originalModel: $scope.model,
                    formOptions: $scope.options,
                    formId: $scope.formId
                };
            }
        }

        module.exports = exports['default'];

        /***/
    },
    /* 18 */
    /***/ function (module, exports, __webpack_require__) {

        'use strict';

        addFormlyNgModelAttrsManipulator.$inject = ["formlyConfig", "$interpolate"];
        Object.defineProperty(exports, '__esModule', {
            value: true
        });

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

        var _angularFix = __webpack_require__(2);

        var _angularFix2 = _interopRequireDefault(_angularFix);

        var _otherUtils = __webpack_require__(9);

        exports['default'] = addFormlyNgModelAttrsManipulator;

        // @ngInject
        function addFormlyNgModelAttrsManipulator(formlyConfig, $interpolate) {
            if (formlyConfig.extras.disableNgModelAttrsManipulator) {
                return;
            }
            formlyConfig.templateManipulators.preWrapper.push(ngModelAttrsManipulator);

            function ngModelAttrsManipulator(template, options, scope) {
                var node = document.createElement('div');
                var skip = options.extras && options.extras.skipNgModelAttrsManipulator;
                if (skip === true) {
                    return template;
                }
                node.innerHTML = template;

                var modelNodes = getNgModelNodes(node, skip);
                if (!modelNodes || !modelNodes.length) {
                    return template;
                }

                addIfNotPresent(modelNodes, 'id', scope.id);
                addIfNotPresent(modelNodes, 'name', scope.name || scope.id);

                addValidation();
                alterNgModelAttr();
                addModelOptions();
                addTemplateOptionsAttrs();
                addNgModelElAttrs();

                return node.innerHTML;

                function addValidation() {
                    if (_angularFix2['default'].isDefined(options.validators) || _angularFix2['default'].isDefined(options.validation.messages)) {
                        addIfNotPresent(modelNodes, 'formly-custom-validation', '');
                    }
                }

                function alterNgModelAttr() {
                    if (isPropertyAccessor(options.key)) {
                        addRegardlessOfPresence(modelNodes, 'ng-model', 'model.' + options.key);
                    }
                }

                function addModelOptions() {
                    if (_angularFix2['default'].isDefined(options.modelOptions)) {
                        addIfNotPresent(modelNodes, 'ng-model-options', 'options.modelOptions');
                        if (options.modelOptions.getterSetter) {
                            addRegardlessOfPresence(modelNodes, 'ng-model', 'options.value');
                        }
                    }
                }

                function addTemplateOptionsAttrs() {
                    if (!options.templateOptions && !options.expressionProperties) {
                        // no need to run these if there are no templateOptions or expressionProperties
                        return;
                    }
                    var to = options.templateOptions || {};
                    var ep = options.expressionProperties || {};

                    var ngModelAttributes = getBuiltInAttributes();

                    // extend with the user's specifications winning
                    _angularFix2['default'].extend(ngModelAttributes, options.ngModelAttrs);

                    // Feel free to make this more simple :-)
                    _angularFix2['default'].forEach(ngModelAttributes, function (val, name) {
                        /* eslint complexity:[2, 14] */
                        var attrVal = undefined,
                            attrName = undefined;
                        var ref = 'options.templateOptions[\'' + name + '\']';
                        var toVal = to[name];
                        var epVal = getEpValue(ep, name);

                        var inTo = _angularFix2['default'].isDefined(toVal);
                        var inEp = _angularFix2['default'].isDefined(epVal);
                        if (val.value) {
                            // I realize this looks backwards, but it's right, trust me...
                            attrName = val.value;
                            attrVal = name;
                        } else if (val.statement && inTo) {
                            attrName = val.statement;
                            if (_angularFix2['default'].isString(to[name])) {
                                attrVal = '$eval(' + ref + ')';
                            } else if (_angularFix2['default'].isFunction(to[name])) {
                                attrVal = ref + '(model[options.key], options, this, $event)';
                            } else {
                                throw new Error('options.templateOptions.' + name + ' must be a string or function: ' + JSON.stringify(options));
                            }
                        } else if (val.bound && inEp) {
                            attrName = val.bound;
                            attrVal = ref;
                        } else if ((val.attribute || val.boolean) && inEp) {
                            attrName = val.attribute || val.boolean;
                            attrVal = '' + $interpolate.startSymbol() + ref + $interpolate.endSymbol();
                        } else if (val.attribute && inTo) {
                            attrName = val.attribute;
                            attrVal = toVal;
                        } else if (val.boolean) {
                            if (inTo && !inEp && toVal) {
                                attrName = val.boolean;
                                attrVal = true;
                            } else {
                                /* eslint no-empty:0 */
                                // empty to illustrate that a boolean will not be added via val.bound
                                // if you want it added via val.bound, then put it in expressionProperties
                            }
                        } else if (val.bound && inTo) {
                            attrName = val.bound;
                            attrVal = ref;
                        }

                        if (_angularFix2['default'].isDefined(attrName) && _angularFix2['default'].isDefined(attrVal)) {
                            addIfNotPresent(modelNodes, attrName, attrVal);
                        }
                    });
                }

                function addNgModelElAttrs() {
                    _angularFix2['default'].forEach(options.ngModelElAttrs, function (val, name) {
                        addRegardlessOfPresence(modelNodes, name, val);
                    });
                }
            }

            // Utility functions
            function getNgModelNodes(node, skip) {
                var selectorNot = _angularFix2['default'].isString(skip) ? ':not(' + skip + ')' : '';
                var skipNot = ':not([formly-skip-ng-model-attrs-manipulator])';
                var query = '[ng-model]' + selectorNot + skipNot + ', [data-ng-model]' + selectorNot + skipNot;
                try {
                    return node.querySelectorAll(query);
                } catch (e) {
                    //this code is needed for IE8, as it does not support the CSS3 ':not' selector
                    //it should be removed when IE8 support is dropped
                    return getNgModelNodesFallback(node, skip);
                }
            }

            function getNgModelNodesFallback(node, skip) {
                var allNgModelNodes = node.querySelectorAll('[ng-model], [data-ng-model]');
                var matchingNgModelNodes = [];

                //make sure this array is compatible with NodeList type by adding an 'item' function
                matchingNgModelNodes.item = function (i) {
                    return this[i];
                };

                for (var i = 0; i < allNgModelNodes.length; i++) {
                    var ngModelNode = allNgModelNodes[i];
                    if (!ngModelNode.hasAttribute('formly-skip-ng-model-attrs-manipulator') && !(_angularFix2['default'].isString(skip) && nodeMatches(ngModelNode, skip))) {
                        matchingNgModelNodes.push(ngModelNode);
                    }
                }

                return matchingNgModelNodes;
            }

            function nodeMatches(node, selector) {
                var div = document.createElement('div');
                div.innerHTML = node.outerHTML;
                return div.querySelector(selector);
            }

            function getBuiltInAttributes() {
                var ngModelAttributes = {
                    focus: {
                        attribute: 'formly-focus'
                    }
                };
                var boundOnly = [];
                var bothBooleanAndBound = ['required', 'disabled'];
                var bothAttributeAndBound = ['pattern', 'minlength'];
                var statementOnly = ['change', 'keydown', 'keyup', 'keypress', 'click', 'focus', 'blur'];
                var attributeOnly = ['placeholder', 'min', 'max', 'step', 'tabindex', 'type'];
                if (formlyConfig.extras.ngModelAttrsManipulatorPreferUnbound) {
                    bothAttributeAndBound.push('maxlength');
                } else {
                    boundOnly.push('maxlength');
                }

                _angularFix2['default'].forEach(boundOnly, function (item) {
                    ngModelAttributes[item] = { bound: 'ng-' + item };
                });

                _angularFix2['default'].forEach(bothBooleanAndBound, function (item) {
                    ngModelAttributes[item] = { boolean: item, bound: 'ng-' + item };
                });

                _angularFix2['default'].forEach(bothAttributeAndBound, function (item) {
                    ngModelAttributes[item] = { attribute: item, bound: 'ng-' + item };
                });

                _angularFix2['default'].forEach(statementOnly, function (item) {
                    var propName = 'on' + item.substr(0, 1).toUpperCase() + item.substr(1);
                    ngModelAttributes[propName] = { statement: 'ng-' + item };
                });

                _angularFix2['default'].forEach(attributeOnly, function (item) {
                    ngModelAttributes[item] = { attribute: item };
                });
                return ngModelAttributes;
            }

            function getEpValue(ep, name) {
                return ep['templateOptions.' + name] || ep['templateOptions[\'' + name + '\']'] || ep['templateOptions["' + name + '"]'];
            }

            function addIfNotPresent(nodes, attr, val) {
                _angularFix2['default'].forEach(nodes, function (node) {
                    if (!node.getAttribute(attr)) {
                        node.setAttribute(attr, val);
                    }
                });
            }

            function addRegardlessOfPresence(nodes, attr, val) {
                _angularFix2['default'].forEach(nodes, function (node) {
                    node.setAttribute(attr, val);
                });
            }

            function isPropertyAccessor(key) {
                return (0, _otherUtils.contains)(key, '.') || (0, _otherUtils.contains)(key, '[') && (0, _otherUtils.contains)(key, ']');
            }
        }
        module.exports = exports['default'];

        /***/
    },
    /* 19 */
    /***/ function (module, exports, __webpack_require__) {

        'use strict';

        addCustomTags.$inject = ["$document"];
        Object.defineProperty(exports, '__esModule', {
            value: true
        });

        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

        var _angularFix = __webpack_require__(2);

        var _angularFix2 = _interopRequireDefault(_angularFix);

        exports['default'] = addCustomTags;

        // @ngInject
        function addCustomTags($document) {
            // IE8 check ->
            // https://msdn.microsoft.com/en-us/library/cc196988(v=vs.85).aspx
            if ($document && $document.documentMode < 9) {
                (function () {
                    var document = $document.get(0);
                    // add the custom elements that we need for formly
                    var customElements = ['formly-field', 'formly-form'];
                    _angularFix2['default'].forEach(customElements, function (el) {
                        document.createElement(el);
                    });
                })();
            }
        }
        module.exports = exports['default'];

        /***/
    }
    /******/])
});
;